/**
 * @msg:数值单位转换
 * @param {*}
 * @return {*}
 */
export const numberUnitFormat = (value) => {
  const param = {}
  const k = 10000
  const sizes = ['', '万', '亿', '万亿']
  let i = null
  if (value < k) {
    param.value = value
    param.unit = ''
  } else {
    i = Math.floor(Math.log(value) / Math.log(k))
    param.value = (value / Math.pow(k, i)).toFixed(2)
    param.unit = sizes[i]
  }
  return param
}
// numberUnitFormat(23232323343.23) => { "value": "232.32", "unit": "亿" }
/**
 * @msg: 千分位转换
 * @param {*}
 * @return {*}
 */
export const thousandFormat = (num, obj) => {
  let param = ''
  if (!obj) {
    //格式化千分位输出
    param = num.toLocaleString()
  } else if (obj && obj.lang === 'en') {
    //格式化为千分位带$符号输出
    param = num.toLocaleString('en', { style: 'currency', currency: 'USD' })
  } else if (obj && obj.lang === 'cn') {
    //格式化为带￥符号输出
    param = num.toLocaleString('cn', { style: 'currency', currency: 'CNY' })
  } else {
    //格式化千分位输出
    param = num.toLocaleString()
  }
  return param
}
// thousandFormat(123456789.0, { lang: 'cn' }) => ¥123,456,789.00

/**
 * @msg: 分转元
 * @param {*}
 * @return {*}
 */
export const convertCentToYuan = (cent) => {
  const tempArr = cent.toString().padStart(3, '0').split('')
  tempArr.splice(-2, 0, '.')
  return tempArr.join('')
}
// convertCentToYuan(100000) => 1000

/**
 * @msg: 平铺数组转树形结构
 * @param {*}
 * @return {*}
 */
export const arrayToTree = (items, childName = 'children') => {
  const result = [] // 存放结果集
  const itemMap = {} //
  for (const item of items) {
    const id = item.id
    const pid = item.parentId

    if (!itemMap[id]) {
      itemMap[id] = {
        [childName]: []
      }
    }
    itemMap[id] = {
      ...item,
      [childName]: itemMap[id][childName]
    }

    const treeItem = itemMap[id]

    if (pid === 0) {
      result.push(treeItem)
    } else {
      // if (!itemMap[pid]) {
      // 	itemMap[pid] = {
      // 		[childName]: [],
      // 	};
      // }
      itemMap[pid][childName].push(treeItem)
    }
  }
  return result
}
// arrayToTree(data) => 返回树形数组

/**
 * @msg: 扁平数组与JSON树结构互转
 * @param {*}
 * @return {*}
 */
export const listToTree = (list, childName = 'children') => {
  const res = []
  const map = list.reduce((res, v) => (res[v.id] = v), {})

  for (const item of list) {
    if (item.parentId === 0) {
      res.push(item)
      continue
    }
    if (item.parentId in map) {
      const parent = map[item.parentId]
      parent[childName] = parent[childName] || []
      parent[childName].push(item)
    }
  }
  return res
}
// listToTree(data) => 返回树形数组

/**
 * @msg: 树形结构转扁平数组列表
 * @param {*}
 * @return {*}
 */
export const treeToList = (data, childName = 'children') => {
  // if (!Array.isArray(data)) {
  // 	return [];
  // }
  return data.reduce(
    (prev, cur) => prev.concat([cur], treeToList(cur[childName] || [])),
    []
  )
}
// treeToList(data) => 返回扁平数组列表

/**
 * 数组去重
 * 如果是纯粹数组，用es6 Set去重，只需要传arr即可
 * @param  {} arr 数组 or 对象数组
 * @param  {} params 数组对象去重时根据key值去重
 */
export const uniq = (arr, params) => {
  if (!Array.isArray(arr)) {
    return arr
  }
  if (params) {
    const obj = {}
    // const newArr = arr.reduce((perv, cur) => {
    //   // error  Expected an assignment or function call and instead saw an expression
    //   // 期望看到的是一个赋值或者函数调用，而看到的是一个表达式
    //   obj[cur[params.key]]
    //     ? ''
    //     : (obj[cur[params.key]] = true) && perv.push(cur)
    //   return perv
    // }, [])
    const newArr = arr.reduce((perv, cur) => {
      // error  Expected an assignment or function call and instead saw an expression
      // 期望看到的是一个赋值或者函数调用，而看到的是一个表达式
      obj[cur[params.key]] ? perv.push(cur) : (perv = '')
      return perv
    }, [])
    return newArr
  } else {
    return Array.from(new Set(arr))
  }
}
// uniq(data, { key: 'id' }) => 返回根据ID去重后的对象数组列表

/**
 * 对象数组去重
 * 数组的对象完全匹配后去重
 * @param  {} data 对象数组
 */
export const uniqObject = (data) => {
  const uniques = []
  const stringify = {}
  for (let i = 0; i < data.length; i++) {
    const keys = Object.keys(data[i])
    keys.sort(function (a, b) {
      return Number(a) - Number(b)
    })
    let str = ''
    for (let j = 0; j < keys.length; j++) {
      str += JSON.stringify(keys[j])
      str += JSON.stringify(data[i][keys[j]])
    }
    // error  Do not access Object.prototype method 'hasOwnProperty' from target object
    // https://blog.csdn.net/qq_36727756/article/details/105464902
    if (!stringify.prototype.hasOwnProperty.call(stringify, str)) {
      uniques.push(data[i])
      stringify[str] = true
    }
  }
  const newUniques = uniques
  return newUniques
}
// uniqObject(data) => 返回去重后的对象数组列表
